FIG. 1 is a block diagram of a computer system 100 for implementing a complex program. The computer system 100 includes an operating system 102 which controls a plurality of processors 104a–104d. The processors 104a–104d are utilized to compile the program 106. The program could be, for example, an operating system such as an AIX operating system.
Typically, a first version of a complex program such as an operating system has errors therewith. In addition, during the development of the program new features are added. During the process, typically several changes may be made in the source code related to the complex program.
One way to implement the complex program is to have a single large directory that contains the entire program. However, if a single large directory were utilized to hold data it would require a significant amount of time to make source code changes in the program. The reason why source code changes would take a significant amount of time is that every time a source code change was made in the program, the entire program, no matter where the source code change was made, would have to be accessed up to that source code change. Attempting to manage revisions in this manner would require a significant amount of time.
To more efficiently compile the complex program from version to version in the development process, the program is broken up into a directory structure where discrete files of the code are placed in specific directories or subdirectories. Within each directory are files related to that particular file of the code.
The program is broken up into directories or subdirectories to allow for different entities to be responsible for different files of the code. The files within the directories that are used in compiling the program can be maintained individually in a program library and accessed as desired. The dependencies of the directories preferably conform to the compile environment conventions of the Open Software Foundation (OSF) Development Environment.
One way of compiling the code files within each of the directories is to use a MAKE facility. The MAKE facility creates a plurality of make files. In an OSF environment, each make file provides the data that is needed to compile the code files within a particular directory and includes the directory's dependencies on other directories. Breaking the complex program up into code files based upon the directory structure allows for quick access to source code changes and also quick identification of those changes. Typically, the code files within one directory can have a dependency on the code file in one or more other directories. That is, the code files of one directory have to be compiled before the code files of one or more other directories.
In compiling the complex program 106, the change in code within each of the directories is accessed by a processor 104a–104d and scheduled by a scheduler (not shown) for compilation prior to integration into an executable program. For successful compilation of the complex program 106, the code files within each of the directories required must be scheduled for compilation in the correct sequence. Furthermore, logically independent directories must be scheduled for compilation before their dependent directories can be compiled.
Scheduling the compilation of directories when there are no dependencies between the directories is relatively simple. However, the scheduling becomes complex when there are compilation dependencies between directories. As before mentioned, different entities are typically responsible for a particular portion of the program. The scheduling is complex because each of the directories is maintained independently of each other on an ongoing basis by the entity that is responsible for a particular directory. This may result in a modification to a particular directory, which introduces dependencies on other directories that are unknown to the scheduler.
Accordingly, if a directory that is dependent upon another directory is compiled before that directory, a deadlock occurs. The deadlock can result in a significant delay in compile cycle time. The delay can significantly negatively impact the development process of each program.
Accordingly, what is needed is a system and method for reducing the compile cycle time of a complex program. The solution should be simple, cost effective and capable of being easily adapted to current technology. The present invention addresses such a need.